
// defineProperty
; (function () {
    return


    var obj = {};
    Object.defineProperty(obj, "num", {
        value: 1,

        // 当且仅当该属性的 writable 为 true 时，
        // 该属性才能被赋值运算符改变。默认为 false。

        writable: true,

        // 当且仅当该属性的 enumerable 为 true 时，
        // 该属性才能够出现在对象的枚举属性中。默认为 false。
        enumerable: false,

        // 当且仅当该属性的 configurable 为 true 时，
        // 该属性描述符才能够被改变，也能够被删除。默认为 false。
        configurable: true
    });
    //  对象 obj 拥有属性 num，值为 1

    // value和get set不能同时存在(    =====注意点=====    )
    // get
    // 一个给属性提供 getter 的方法，
    // 如果没有 getter 则为 undefined。
    // 该方法返回值被用作属性值。默认为 undefined。

    //set
    // 一个给属性提供 setter 的方法，
    // 如果没有 setter 则为 undefined。
    // 该方法将接受唯一参数，并将该参数的新值分配给该属性。
    // 默认为 undefined。


})();

// proxy
; (function () {
    return
    let obj = {
        a: 5
    }
    var proxy = new Proxy(obj, {
        get: function (obj, prop) {
            console.log('设置 get 操作')
            return obj[prop] + 1;
        },
        set: function (obj, prop, value) {
            console.log('设置 set 操作')
            obj[prop] = value;
        }
    });

    proxy.time = 35; // 设置 set 操作

    console.log(proxy.time); // 设置 get 操作 // 35
    console.log(proxy.a); // 设置 get 操作 // 5
    console.log(obj.a); // 5
    console.log(obj); // { a: 5, time: 35 }

    // 从这点看, proxy对象更像是obj对象的代理, 又不改变obj对象

})();

// proxy拦截操作,  就是可以对对象的方法进行拦截 还是不改变原函数
; (function () {
    return
    // 使用 has 方法隐藏某些属性，不被 in 运算符发现
    var handler = {
        has(target, key) {
            if (key[0] === '_') {
                return false;
            }
            return key in target;
        }
    };
    var target = { _prop: 'foo', prop: 'foo' };
    var proxy = new Proxy(target, handler);
    console.log('_prop' in proxy); // false
    console.log('_prop' in target); // true




    let target2 = {
        _bar: 'foo',
        _prop: 'bar',
        prop: 'baz'
    };
    // 使用 ownKeys 方法隐藏某些属性，不被 Object.keys枚举
    let handler2 = {
        
        ownKeys(target) {
            return Reflect.ownKeys(target).filter(key => key[0] !== '_');
        }
    };

    let proxy2 = new Proxy(target2, handler2);
    for (let key of Object.keys(proxy2)) {
        console.log(target2[key]);
    }
    // "baz"

    for (let key of Object.keys(target2)) {
        console.log(target2[key]);
    }
    // foo
    // bar
    // baz


})();